{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 定义模型\n",
    "\n",
    "注意DDGP中critic网络的输入是state加上action。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "class Actor(nn.Module):\n",
    "    def __init__(self, state_dim, action_dim, hidden_dim = 256, init_w=3e-3):\n",
    "        super(Actor, self).__init__()  \n",
    "        self.linear1 = nn.Linear(state_dim, hidden_dim)\n",
    "        self.linear2 = nn.Linear(hidden_dim, hidden_dim)\n",
    "        self.linear3 = nn.Linear(hidden_dim, action_dim)\n",
    "        self.linear3.weight.data.uniform_(-init_w, init_w)\n",
    "        self.linear3.bias.data.uniform_(-init_w, init_w)\n",
    "        \n",
    "    def forward(self, x):\n",
    "        x = F.relu(self.linear1(x))\n",
    "        x = F.relu(self.linear2(x))\n",
    "        x = torch.tanh(self.linear3(x))\n",
    "        return x\n",
    "        \n",
    "class Critic(nn.Module):\n",
    "    def __init__(self, state_dim, action_dim, hidden_dim=256, init_w=3e-3):\n",
    "        super(Critic, self).__init__()\n",
    "        \n",
    "        self.linear1 = nn.Linear(state_dim + action_dim, hidden_dim)\n",
    "        self.linear2 = nn.Linear(hidden_dim, hidden_dim)\n",
    "        self.linear3 = nn.Linear(hidden_dim, 1)\n",
    "        # 随机初始化为较小的值\n",
    "        self.linear3.weight.data.uniform_(-init_w, init_w)\n",
    "        self.linear3.bias.data.uniform_(-init_w, init_w)\n",
    "        \n",
    "    def forward(self, state, action):\n",
    "        # 按维数1拼接\n",
    "        x = torch.cat([state, action], 1)\n",
    "        x = F.relu(self.linear1(x))\n",
    "        x = F.relu(self.linear2(x))\n",
    "        x = self.linear3(x)\n",
    "        return x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 定义经验回放"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "from collections import deque\n",
    "import random\n",
    "class ReplayBuffer:\n",
    "    def __init__(self, capacity: int) -> None:\n",
    "        self.capacity = capacity\n",
    "        self.buffer = deque(maxlen=self.capacity)\n",
    "    def push(self,transitions):\n",
    "        '''_summary_\n",
    "        Args:\n",
    "            trainsitions (tuple): _description_\n",
    "        '''\n",
    "        self.buffer.append(transitions)\n",
    "    def sample(self, batch_size: int, sequential: bool = False):\n",
    "        if batch_size > len(self.buffer):\n",
    "            batch_size = len(self.buffer)\n",
    "        if sequential: # sequential sampling\n",
    "            rand = random.randint(0, len(self.buffer) - batch_size)\n",
    "            batch = [self.buffer[i] for i in range(rand, rand + batch_size)]\n",
    "            return zip(*batch)\n",
    "        else:\n",
    "            batch = random.sample(self.buffer, batch_size)\n",
    "            return zip(*batch)\n",
    "    def clear(self):\n",
    "        self.buffer.clear()\n",
    "    def __len__(self):\n",
    "        return len(self.buffer)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 定义策略"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch.optim as optim\n",
    "import numpy as np\n",
    "\n",
    "class Policy:\n",
    "    def __init__(self, cfg):\n",
    "        self.device = torch.device(cfg.device)\n",
    "        self.critic = Critic(cfg.state_dim, cfg.action_dim).to(self.device)\n",
    "        self.target_critic = Critic(cfg.state_dim, cfg.action_dim).to(self.device)\n",
    "        self.actor = Actor(cfg.state_dim, cfg.action_dim).to(self.device)\n",
    "        self.target_actor = Actor(cfg.state_dim, cfg.action_dim).to(self.device)\n",
    "        \n",
    "        # 复制参数到目标网络\n",
    "        for target_param, param in zip(self.target_critic.parameters(), self.critic.parameters()):\n",
    "            target_param.data.copy_(param.data)\n",
    "        for target_param, param in zip(self.target_actor.parameters(), self.actor.parameters()):\n",
    "            target_param.data.copy_(param.data)\n",
    "        self.critic_optimizer = optim.Adam(self.critic.parameters(),  lr=cfg.critic_lr)\n",
    "        self.actor_optimizer = optim.Adam(self.actor.parameters(), lr=cfg.actor_lr)\n",
    "        self.memory = ReplayBuffer(cfg.buffer_size)\n",
    "        self.batch_size = cfg.batch_size\n",
    "        self.gamma = cfg.gamma  # 折扣因子\n",
    "        self.tau = cfg.tau  # 软更新参数\n",
    "        self.action_high = cfg.action_space.high[0]\n",
    "        self.action_low = cfg.action_space.low[0]\n",
    "        self.action_scale = (self.action_high - self.action_low) / 2\n",
    "        self.action_bias = (self.action_high + self.action_low) / 2\n",
    "\n",
    "    def sample_action(self, state):\n",
    "        state = torch.FloatTensor(state).unsqueeze(0).to(self.device)\n",
    "        mu = self.actor(state)\n",
    "        action = mu * self.action_scale + self.action_bias\n",
    "        return action.cpu().detach().numpy()[0]\n",
    "    \n",
    "    @torch.no_grad()\n",
    "    def predict_action(self, state):\n",
    "        ''' 用于预测，不需要计算梯度\n",
    "        '''\n",
    "        state = torch.FloatTensor(state).unsqueeze(0).to(self.device)\n",
    "        mu = self.actor(state)\n",
    "        action = mu * self.action_scale + self.action_bias\n",
    "        return action.cpu().detach().numpy()[0]\n",
    "    \n",
    "    def update(self):\n",
    "        if len(self.memory) < self.batch_size: # 当memory中不满足一个批量时，不更新策略\n",
    "            return\n",
    "        # 从经验回放中中随机采样一个批量的transition\n",
    "        state, action, reward, next_state, done = self.memory.sample(self.batch_size)\n",
    "        # 转变为张量\n",
    "        state = torch.FloatTensor(np.array(state)).to(self.device)\n",
    "        next_state = torch.FloatTensor(np.array(next_state)).to(self.device)\n",
    "        action = torch.FloatTensor(np.array(action)).to(self.device)\n",
    "        reward = torch.FloatTensor(reward).unsqueeze(1).to(self.device)\n",
    "        done = torch.FloatTensor(np.float32(done)).unsqueeze(1).to(self.device)\n",
    "        # 注意看伪代码，这里的actor损失就是对应策略即actor输出的action下对应critic值的负均值\n",
    "        actor_loss = self.critic(state, self.actor(state))\n",
    "        actor_loss = - actor_loss.mean()\n",
    "\n",
    "        next_action = self.target_actor(next_state)\n",
    "        target_value = self.target_critic(next_state, next_action.detach())\n",
    "        # 这里的expected_value就是伪代码中间的y_i  \n",
    "        expected_value = reward + (1.0 - done) * self.gamma * target_value\n",
    "        expected_value = torch.clamp(expected_value, -np.inf, np.inf)\n",
    "        # 注意这里的action是经过缩放和平移的，所以要逆操作\n",
    "        action = (action - self.action_bias) / self.action_scale\n",
    "        actual_value = self.critic(state, action)\n",
    "        critic_loss = nn.MSELoss()(actual_value, expected_value.detach())\n",
    "        \n",
    "        self.actor_optimizer.zero_grad()\n",
    "        actor_loss.backward()\n",
    "        self.actor_optimizer.step()\n",
    "        self.critic_optimizer.zero_grad()\n",
    "        critic_loss.backward()\n",
    "        self.critic_optimizer.step()\n",
    "        # 各自目标网络的参数软更新\n",
    "        for target_param, param in zip(self.target_critic.parameters(), self.critic.parameters()):\n",
    "            target_param.data.copy_(\n",
    "                target_param.data * (1.0 - self.tau) +\n",
    "                param.data * self.tau\n",
    "            )\n",
    "        for target_param, param in zip(self.target_actor.parameters(), self.actor.parameters()):\n",
    "            target_param.data.copy_(\n",
    "                target_param.data * (1.0 - self.tau) +\n",
    "                param.data * self.tau\n",
    "            )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 定义OU噪声"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "class OUNoise(object):\n",
    "    '''Ornstein–Uhlenbeck噪声\n",
    "    '''\n",
    "    def __init__(self, action_space, mu=0.0, theta=0.15, max_sigma=0.3, min_sigma=0.3, decay_period=100000):\n",
    "        self.mu           = mu # OU噪声的参数\n",
    "        self.theta        = theta # OU噪声的参数\n",
    "        self.sigma        = max_sigma # OU噪声的参数\n",
    "        self.max_sigma    = max_sigma\n",
    "        self.min_sigma    = min_sigma\n",
    "        self.decay_period = decay_period\n",
    "        self.action_dim   = action_space.shape[0]\n",
    "        self.low          = action_space.low\n",
    "        self.high         = action_space.high\n",
    "        self.reset()\n",
    "    def reset(self):\n",
    "        self.obs = np.ones(self.action_dim) * self.mu\n",
    "    def evolve_obs(self):\n",
    "        x  = self.obs\n",
    "        dx = self.theta * (self.mu - x) + self.sigma * np.random.randn(self.action_dim)\n",
    "        self.obs = x + dx\n",
    "        return self.obs\n",
    "    def get_action(self, action, t=0):\n",
    "        ou_obs = self.evolve_obs()\n",
    "        self.sigma = self.max_sigma - (self.max_sigma - self.min_sigma) * min(1.0, t / self.decay_period) # sigma会逐渐衰减\n",
    "        return np.clip(action + ou_obs, self.low, self.high) # 动作加上噪声后进行剪切"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 定义训练"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "\n",
    "import gymnasium as gym\n",
    "\n",
    "def train(cfg):\n",
    "    env = gym.make(cfg.env_id)\n",
    "    setattr(cfg, \"action_space\", env.action_space)\n",
    "    setattr(cfg, \"state_dim\", env.observation_space.shape[0])\n",
    "    setattr(cfg, \"action_dim\", env.action_space.shape[0])\n",
    "    ou_noise = OUNoise(env.action_space)  # 动作噪声\n",
    "    policy = Policy(cfg)\n",
    "    rewards,frames = [],[]\n",
    "    for i_ep in range(cfg.train_eps):\n",
    "        state, _ = env.reset()\n",
    "        ou_noise.reset()\n",
    "        ep_reward = 0\n",
    "        for i_step in range(cfg.max_steps):\n",
    "            action = policy.sample_action(state)\n",
    "            action = ou_noise.get_action(action, i_step+1) \n",
    "            next_state, reward, terminated, truncated , info = env.step(action)  # 更新环境，返回transition\n",
    "            policy.memory.push((state, action, reward, next_state, truncated))  # 保存transition\n",
    "            state = next_state  # 更新下一个状态\n",
    "            ep_reward += reward\n",
    "            policy.update()\n",
    "            state = next_state\n",
    "            if truncated:\n",
    "                break\n",
    "        rewards.append(ep_reward)\n",
    "        frames.append(i_ep)\n",
    "        if (i_ep+1)%10 == 0:\n",
    "            print(f\"回合：{i_ep+1}/{cfg.train_eps}，奖励：{ep_reward:.2f}\")\n",
    "    env.close()\n",
    "    return {'rewards':rewards, 'frames':frames}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 设置参数"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Config:\n",
    "    def __init__(self) -> None:\n",
    "        self.algo_name = 'DDPG' # 算法名称\n",
    "        self.env_id = 'Pendulum-v1' # 环境id\n",
    "        self.mode = 'train'\n",
    "        self.seed = 1 # 随机种子，便于复现，0表示不设置\n",
    "        self.train_eps = 200 # 训练的回合数\n",
    "        self.test_eps = 20 # 测试的回合数\n",
    "        self.max_steps = 100000 # 每个回合的最大步数，超过该数则游戏强制终止\n",
    "        self.gamma = 0.99 # 折扣因子\n",
    "        self.buffer_size = 8000 # 经验回放池的容量\n",
    "        self.hidden_dim = 256 # 神经网络的隐藏层维度\n",
    "        self.batch_size = 128 # 批次大小\n",
    "        self.critic_lr = 1e-3 \n",
    "        self.actor_lr = 1e-4\n",
    "        self.tau = 1e-2\n",
    "        self.critic_hidden_dim = 256\n",
    "        self.actor_hidden_dim = 256\n",
    "        self.device = 'cpu' if not torch.cuda.is_available() else 'cuda'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 开始训练"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "import os\n",
    "\n",
    "def smooth(data: list, weight: float = 0.9):\n",
    "    '''用于平滑曲线，类似于Tensorboard中的smooth曲线\n",
    "    '''\n",
    "    last = data[0] \n",
    "    smoothed = []\n",
    "    for point in data:\n",
    "        smoothed_val = last * weight + (1 - weight) * point  # 计算平滑值\n",
    "        smoothed.append(smoothed_val)                    \n",
    "        last = smoothed_val                                \n",
    "    return smoothed\n",
    "\n",
    "def plot_rewards(cfg, frames, rewards):\n",
    "    ''' 画图\n",
    "    '''\n",
    "    sns.set_theme(style=\"darkgrid\")\n",
    "    plt.figure()  # 创建一个图形实例，方便同时多画几个图\n",
    "    plt.title(f\"{cfg.mode}ing curve on {cfg.device} of {cfg.algo_name} for {cfg.env_id}\")\n",
    "    plt.xlabel('frames')\n",
    "    plt.plot(frames, rewards, label='rewards')\n",
    "    plt.plot(frames, smooth(rewards), label='smoothed rewards')\n",
    "    plt.legend()\n",
    "    plt.show()\n",
    "\n",
    "def print_cfgs(cfg):\n",
    "    ''' 打印参数\n",
    "    '''\n",
    "    cfg_dict = vars(cfg)\n",
    "    print(\"Hyperparameters:\")\n",
    "    print(''.join(['=']*80))\n",
    "    tplt = \"{:^20}\\t{:^20}\\t{:^20}\"\n",
    "    print(tplt.format(\"Name\", \"Value\", \"Type\"))\n",
    "    for k,v in cfg_dict.items():\n",
    "        if v.__class__.__name__ == 'list':\n",
    "            v = str(v)\n",
    "        print(tplt.format(k,v,str(type(v))))   \n",
    "    print(''.join(['=']*80))\n",
    "\n",
    "def all_seed(seed: int = 0):\n",
    "    ''' 设置随机种子\n",
    "    '''\n",
    "    if seed == 0:\n",
    "        return\n",
    "    np.random.seed(seed)\n",
    "    random.seed(seed)\n",
    "    torch.manual_seed(seed) # config for CPU\n",
    "    torch.cuda.manual_seed(seed) # config for GPU\n",
    "    os.environ['PYTHONHASHSEED'] = str(seed) # config for python scripts\n",
    "    # config for cudnn\n",
    "    torch.backends.cudnn.deterministic = True\n",
    "    torch.backends.cudnn.benchmark = False\n",
    "    torch.backends.cudnn.enabled = False  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hyperparameters:\n",
      "================================================================================\n",
      "        Name        \t       Value        \t        Type        \n",
      "     algo_name      \t        DDPG        \t   <class 'str'>    \n",
      "       env_id       \t    Pendulum-v1     \t   <class 'str'>    \n",
      "        mode        \t       train        \t   <class 'str'>    \n",
      "        seed        \t         1          \t   <class 'int'>    \n",
      "     train_eps      \t        200         \t   <class 'int'>    \n",
      "      test_eps      \t         20         \t   <class 'int'>    \n",
      "     max_steps      \t       100000       \t   <class 'int'>    \n",
      "       gamma        \t        0.99        \t  <class 'float'>   \n",
      "    buffer_size     \t        8000        \t   <class 'int'>    \n",
      "     hidden_dim     \t        256         \t   <class 'int'>    \n",
      "     batch_size     \t        128         \t   <class 'int'>    \n",
      "     critic_lr      \t       0.001        \t  <class 'float'>   \n",
      "      actor_lr      \t       0.0001       \t  <class 'float'>   \n",
      "        tau         \t        0.01        \t  <class 'float'>   \n",
      " critic_hidden_dim  \t        256         \t   <class 'int'>    \n",
      "  actor_hidden_dim  \t        256         \t   <class 'int'>    \n",
      "       device       \t        cpu         \t   <class 'str'>    \n",
      "================================================================================\n",
      "回合：10/200，奖励：-1272.14\n",
      "回合：20/200，奖励：-638.64\n",
      "回合：30/200，奖励：-129.20\n",
      "回合：40/200，奖励：-282.43\n",
      "回合：50/200，奖励：-127.83\n",
      "回合：60/200，奖励：-357.17\n",
      "回合：70/200，奖励：-471.26\n",
      "回合：80/200，奖励：-119.32\n",
      "回合：90/200，奖励：-126.43\n",
      "回合：100/200，奖励：-4.09\n",
      "回合：110/200，奖励：-122.91\n",
      "回合：120/200，奖励：-504.41\n",
      "回合：130/200，奖励：-278.38\n",
      "回合：140/200，奖励：-374.14\n",
      "回合：150/200，奖励：-375.95\n",
      "回合：160/200，奖励：-247.60\n",
      "回合：170/200，奖励：-236.30\n",
      "回合：180/200，奖励：-123.79\n",
      "回合：190/200，奖励：-479.75\n",
      "回合：200/200，奖励：-237.48\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 获取参数\n",
    "cfg = Config() \n",
    "all_seed(cfg.seed)\n",
    "print_cfgs(cfg)\n",
    "res = train(cfg)\n",
    "plot_rewards(cfg, res['frames'], res['rewards'])"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.7.13 ('easyrl')",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.14"
  },
  "orig_nbformat": 4,
  "vscode": {
   "interpreter": {
    "hash": "8994a120d39b6e6a2ecc94b4007f5314b68aa69fc88a7f00edf21be39b41f49c"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
